# Better Any
Rust RFC for `non_static_type_id` feature has been reverted.
Which means in foreseeable future there will be no built-in way in rust to get type id for non-static type
let alone safely use it to downcast to a particular type.
This crate provides tools to do these things safely for types with single lifetime.
Although looks like it is technically possible to extend this approach for multiple lifetimes,
consistent api and derive macro would be much harder to create and use because of the necessity
to properly handle lifetime relations.
Feel free to create an issue if you have actual use case where you need this functionality for multiple lifetimes.
Also it has better downcasting that allows you do downcast not just from `dyn Tid` (like `dyn Any`) but from
any trait object that implements `Tid`.
So there is no more need to extend your traits with` fn to_any(&self)-> &dyn Any`
MSRV: `1.41.0-stable`
### Usage
Basically in places where before you have used `dyn Any` you can use `dyn Tid<'a>`
- If your type is generic you should derive `Tid` implementation for it with `Tid` derive macro.
Then to retrieve back concrete type `::downcast_*` methods should be used.
- If your type is not generic/implements Any you can create `dyn Any` and convert it to `dyn Tid`.
Then to retrieve back concrete type `::downcast_any_*` methods should be used
- If your type is not generic and local to your crate you also can derive `Tid` but then you need to be careful
to use methods that corresponds to the way you create `dyn Tid` for that particular type.
Otherwise downcasting will return `None`.
If all your types can implement `Tid` to avoid confusion
recommended way is to use first option even if some types implement `Any`.
If there are some types that implement `Any` and can't implement `Tid` (i.e. types from other library),
recommended way is to use second option for all types that implement `Any` to reduce confusion to minimum.
### Interoperability with Any
Unfortunately you can't just use `Tid` everywhere because currently it is impossible
to implement `Tid` for `T:Any` since it would conflict with any other possible `Tid` implementation.
To overcome this limitation there is a `From` impl to go from `dyn Any` to `dyn Tid`
But `Any` and `Tid` deliberately return different type ids because otherwise `Type<'a>` and `Type<'static>`
would be indistinguishable and it would allow to go from `Type<'static>` to `Type<'a>` via `dyn Tid`
which is obviously unsound for invariant and contravariant structs.
Although if you are using `dyn Trait` where `Trait:Tid` all of this wouldn't work,
and you are left with `Tid` only.
### Safety
It is safe because created trait object preserve lifetime information,
thus allowing us to safely downcast with proper lifetime.
Otherwise internally it is plain old `Any`.